Synthetic Chemotaxis and Collective Behavior in Active Matter

Conspectus: The ability to navigate in chemical gradients, called chemotaxis, is crucial for the survival of microorganisms. It allows them to find food and to escape from toxins. Many microorganisms can produce the chemicals to which they respond themselves and use chemotaxis for signalling which can be seen as a basic form of communication. Remarkably, the past decade has let to the development of synthetic microswimmers like e.g. autophoretic Janus colloids, which can self-propel through a solvent, analogously to bacteria and other microorganims. The mechanism underlying their self-propulsion involves the production of certain chemicals. The same chemicals involved in the self-propulsion mechanism also act on other microswimmers and bias their swimming direction towards (or away from) the producing microswimmer. Synthetic microswimmers therefore provide a synthetic analogue to chemotactic motile microorganisms. When these interactions are attractive, they commonly lead to clusters, even at low particle density. These clusters may either proceed towards macrophase separation, resembling Dictyostelium aggregation, or, as shown very recently, lead to dynamic clusters of self-limited size (dynamic clustering) as seen in experiments in autophoretic Janus colloids. Besides the classical case where chemical interactions are attractive, this Account discusses, as its main focus, repulsive chemical interactions, which can create a new and less known avenue to pattern formation in active systems leading to a variety of pattern, including clusters which are surrounded by shells of chemicals, travelling waves and more complex continously reshaping patterns. In all these cases `synthetic signalling' can crucially determine the collective behavior of synthetic microswimmer ensembles and can be used as a design principle to create patterns in motile active particles

Errors for the Common Man: Hiding the unintelligable in Haskell

If a library designer takes full advantage of HaskellÆs rich type system and type-level programming capabilities, then the resulting library will frequently inflict huge and unhelpful error messages on the library user. These error messages are typically in terms of the library and do not refer to the call-site of the library by the library user, nor provide any guidance to the user as to how to fix the error. The increasing appetite for programmable type-level computation makes this a critical issue, as the advantages and capabilities of type-level computation are nullified if useful error messages cannot be returned to the user. We present a novel technique that neatly side-steps the default error messages and allows the library programmer to control the generation of error messages that are statically returned to the user. Thus with this technique, there is no longer any drawback to using the full power of HaskellÆs type system.Submitted versio

Safely Speaking in Tongues: Statically Checking Domain Specific Languages in Haskell

Haskell makes it very easy to build and use Domain Specific Languages (DSLs). However, it is frequently the case that a DSL has invariants that can not be easily enforced statically, resulting in runtime checks. This is a great pity given HaskellÆs rich and powerful type system and leads to all the usual problems of dynamic checking. We believe that Domain Specific Languages are becoming more popular: the internet itself is a good example of many DSLs (HTML, CSS, JavaScript, Flash, etc), and more seem to be being added every day; most graphics cards already accept programs written in the DSL OpenGL Shading Language (GLSL); and the predicted growth of heterogeneous CPUs (for example IBMÆs Cell CPU) will demand many different DSLs for the various programming models and instruction sets that become available. We present a technique that allows invariants of any given DSL to be lifted into the Haskell type system. This removes the need for runtime checks of the DSL and prevents programs that violate the invariants of the DSL from ever being compiled or executed. As a result we avoid the pitfalls of dynamic checking and return the user of the DSL to the safety and tranquillity of the strongly statically typed Haskell world

On the Execution of Ambients

Successfully harnessing multi-threaded programming has recently received renewed attention. The GHz war of the last years has been replaced with a parallelism war, each manufacturer seeking to produce CPUs supporting a greater number of threads in parallel execution. The Ambient calculus offers a simple yet powerful means to model communication, distributed computation and mobility. However, given its first class support for concurrency, we sought to investigate the utility of the Ambient calculus for practical programming purposes. Although too low-level to be considered as a general-purpose programming language itself, the Ambient calculus is nevertheless a suitable virtual machine for the execution of mobile and distributed higher-level languages. We present the Glint Virtual Machine: an interpreter for the Safe Boxed Ambient calculus. The GlintVM provides an effective platform for mobile, distributed and parallel computation and should ease some of the difficulties of writing compilers for languages that can exploit the new thread-parallel architectures

Session Types in Haskell: Updating Message Passing for the 21st Century

Session Types allow plans of conversation between two concurrent processes to be treated as types. Type checking then ensures that communication between processes is safe: i.e. it obeys the protocol specified by the session type. Thus Session Types offer a means to establish conformance to protocols in both distributed applications and multi-threaded programming. We incorporate Session Types into Haskell as a tool for concurrent programming. Our implementation, which is a standard Haskell library, presents a monadic API to the programmer. Using the library looks and feels very much like normal monadic computation and thus there is a shallow learning curve for the Haskell programmer. Our implementation lifts the invariants and properties of Session Types into Haskells rich type system. This allows our implementation to statically verify the use of the communication primitives provided without an additional type checker, preprocessor or modification to the compiler. Our implementation supports multiple concurrent communication channels, individual processes can interleave actions across any number of open channels, and channels themselves can be sent and received. New channels can be created between pre-existing processes as well as to newly created processes. Communication is asynchronous and fully polymorphic. To our knowledge, no other implementation of Session Types is available in any language which matches our library in terms of functionality and supported features. We describe the key aspects of our implementation and demonstrate, through a running example, its usage and flexibility

Ulta-slow relaxation in discontinuous-film based electron glasses

We present field effect measurements on discontinuous 2D thin films which are composed of a sub monolayer of nano-grains of Au, Ni, Ag or Al. Like other electron glasses these systems exhibit slow conductance relaxation and memory effects. However, unlike other systems, the discontinuous films exhibit a dramatic slowing down of the dynamics below a characteristic temperature $T^*$. $T^*$ is typically between 10-50K and is sample dependent. For $T<T^*$ the sample exhibits a few other peculiar features such as repeatable conductance fluctuations in millimeter size samples. We suggest that the enhanced system sluggishness is related to the current carrying network becoming very dilute in discontinuous films so that the system contains many parts which are electrically very weakly connected and the transport is dominated by very few weak links. This enables studying the glassy properties of the sample as it transitions from a macroscopic sample to a mesocopic sample, hence, the results provide new insight on the underlying physics of electron glasses.Comment: 4 pages, 4 figure

Softly safely spoken: Role playing for Session Types

Session types have made much progress at permitting programs be statically verified concordant with a specified protocol. However, it is difficult to build abstractions of, or encapsulate Session types, thus limiting their flexibility. Global session types add further constraints to communication, by permitting the order of exchanges amongst many participants to be specified. The cost is that the number of participants is statically fixed. We introduce Roles in which, similarly to global session types, the number of roles and the conversations involving roles are statically known, but participants can dynamically join and leave roles and the number of participants within a role is not statically known. Statically defined roles which conform to a specified conversation can be dynamically instantiated, participants can be members of multiple roles simultaneously and can participate in multiple conversations concurrently